home *** CD-ROM | disk | FTP | other *** search
/ No Fragments Archive 12: Textmags & Docs / nf_archive_12.iso / MAGS / SOURCES / ATARI_SRC.ZIP / atari source / AHDI / TTFHDX / DEFLST.C < prev    next >
Encoding:
C/C++ Source or Header  |  2001-02-09  |  8.5 KB  |  331 lines

  1. /*  deflst.c */
  2.  
  3. /*  21-Jan-88    ml    Started this.    */
  4.  
  5. #include <obdefs.h>
  6. #include <gemdefs.h>
  7. #include <osbind.h>
  8. #include "fhdx.h"
  9. #include "define.h"
  10. #include "part.h"
  11. #include "bsl.h"
  12. #include "deflst.h"
  13. #include "addr.h"
  14.  
  15.  
  16. /* Externs from fhdx.c */
  17. extern SECTOR *badbuf;
  18. extern int maxbadsects;
  19. extern int wdesk, hdesk;
  20. extern int rebootp;
  21.  
  22. /* Globals for this file */
  23. int npndefs;        /* number of defects entered */
  24. PADDR *nppaddr;        /* inputted defect list */
  25.  
  26. /*
  27.  *  Figure out disk format and tester used.
  28.  *    Return:
  29.  *        NPUTSTRT - ready to start the inputing.
  30.  *        NPUTCN - user bail out.
  31.  */
  32. figtst()
  33. {
  34.     int done=0, selfmt=0, seltst=0;
  35.     
  36.     while (!done) {
  37.         done = TRUE;
  38.         npdeflst[TSTRMFM].ob_state = NORMAL;
  39.         npdeflst[TSTRRLL].ob_state = NORMAL;
  40.         npdeflst[NPUTSTRT].ob_state = NORMAL;
  41.         npdeflst[NPUTCN].ob_state = NORMAL;
  42.         if (execform(npdeflst, 0) != NPUTSTRT)
  43.             return NPUTCN;
  44.     
  45.         if (npdeflst[TSTRMFM].ob_state & SELECTED) {
  46.             tst = MFM;
  47.             seltst = 1;
  48.         } else if (npdeflst[TSTRRLL].ob_state & SELECTED) {
  49.             tst = RLL;
  50.             seltst = 1;
  51.         }
  52.         
  53.         if (!seltst) {        /* haven't selected either */
  54.             done = 0;            /* Prompt them again */
  55.         }
  56.     }
  57.     return NPUTSTRT;
  58. }
  59.  
  60.  
  61.  
  62. /*
  63.  * Input defects.
  64.  */
  65. nputdeflst()
  66. {
  67.     int stat;        /* status return from user */    
  68.     int done = 0;
  69.     int stent;        /* starting entry to display */
  70.     int ret;
  71.  
  72.     /* Allocate memory to hold defects */
  73.     if ((nppaddr = mymalloc(maxbadsects*(sizeof(PADDR)))) <= 0) {
  74.         err(nomemory);
  75.         return NOMEM;
  76.     }
  77.     
  78.     npndefs = 0;        /* no defects entered yet */
  79.         
  80.     /* Put up box for input */
  81.     nputform[NPUTDONE].ob_state = NORMAL;
  82.     nputform[NPUTNXT].ob_state = NORMAL;
  83.     strcpy((nputform[NPHDNUM].ob_spec)->te_ptext, "@");
  84.     strcpy((nputform[NPCYLNUM].ob_spec)->te_ptext, "@234");
  85.     strcpy((nputform[NPBYTOFF].ob_spec)->te_ptext, "@2345");
  86.     graf_mouse(ARROW, 0L);
  87.     dsplymsg(nputform);
  88.     stent = NPHDNUM;
  89.     while (!done) {
  90.         nputform[NPUTDONE].ob_state = NORMAL;    /* reset DONE button */
  91.     nputform[NPUTNXT].ob_state = NORMAL;    /* reset NEXT button */
  92.     objc_draw(nputform, NPUTDONE, MAX_DEPTH, 0, 0, wdesk, hdesk);
  93.     objc_draw(nputform, NPUTNXT, MAX_DEPTH, 0, 0, wdesk, hdesk);
  94.         stat = form_do(nputform, stent);    /* hand over to user */
  95.         
  96.         /* Check validity of input and perform appropiate action */
  97.         switch (chknput(nputform, NPHDNUM, NPCYLNUM, NPBYTOFF)) {
  98.             
  99.             case OK:
  100.                 if (npndefs == maxbadsects) {
  101.                     err(deffull);
  102.                     done = TRUE;
  103.                     break;
  104.                 }
  105.                 gpaddr(&nppaddr[npndefs], nputform, NPHDNUM, NPCYLNUM,
  106.                         NPBYTOFF);
  107.                 npndefs++;
  108.         if (stat == NPUTDONE) {    /* no more input */
  109.                     done = TRUE;    /* Exit */
  110.             } else {
  111.             clrnput(nputform, NPHDNUM, NPCYLNUM, NPBYTOFF, NPUTBOX);
  112.             stent = NPHDNUM;
  113.         }
  114.                 break;
  115.                 
  116.             case INCMPL:
  117.                 form_alert(1, npcmpent);
  118.                 stent = NPHDNUM;
  119.                 break;
  120.                 
  121.             case EMPTY:
  122.         if (stat == NPUTDONE) {    /* no more input */
  123.                     done = TRUE;        /* Exit */
  124.             } else 
  125.             stent = NPHDNUM;
  126.                 break;
  127.             
  128.             case HD2BIG:
  129.                 form_alert(1, bghdnum);
  130.                 clrnput(nputform, NPHDNUM, -1, -1, NPUTBOX);
  131.                 stent = NPHDNUM;
  132.                 break;
  133.  
  134.         case CYLNUM0:
  135.             if (form_alert(1, cylis0) != 1) {
  136.             clrnput(nputform, -1, NPCYLNUM, -1, NPUTBOX);
  137.             stent = NPCYLNUM;
  138.             } else {
  139.                 ret = err(cyl0bad);
  140.                 goto nputend;
  141.             }
  142.                 break;
  143.                 
  144.             case CYL2BIG:
  145.                 form_alert(1, bgcylnum);
  146.                 clrnput(nputform, -1, NPCYLNUM, -1, NPUTBOX);
  147.                 stent = NPCYLNUM;
  148.                 break;
  149.  
  150.             case BYT2BIG:
  151.                 form_alert(1, bgbytnum);
  152.                 clrnput(nputform, -1, -1, NPBYTOFF, NPUTBOX);
  153.                 stent = NPBYTOFF;
  154.                 break;
  155.                 
  156.             default:
  157.                 break;
  158.         }
  159.     }
  160.     ret = OK;
  161. nputend:
  162.     erasemsg();
  163.     return (ret);
  164. }
  165.  
  166.  
  167.  
  168. /* 
  169.  *  Get validated physical block address.
  170.  */
  171. gpaddr(paddr, entry, hdnum, cylnum, btoffst)
  172. PADDR *paddr;
  173. OBJECT entry[];
  174. int hdnum, cylnum, btoffst;
  175. {
  176.     paddr->exist = TRUE;
  177.     paddr->head = atoi(entry[hdnum].ob_spec->te_ptext);
  178.     paddr->cylndr = atoi(entry[cylnum].ob_spec->te_ptext);
  179.     paddr->btoffst = atoi(entry[btoffst].ob_spec->te_ptext);
  180. }
  181.  
  182.  
  183. /*
  184.  * Clear value(s) current entry only if index is passed in.
  185.  *    positive ?num - index
  186.  *    negative ?num - don't clear it
  187.  */
  188. clrnput(entry, hdnum, cylnum, btoffst, boxnum)
  189. OBJECT entry[];
  190. int hdnum, cylnum, btoffst, boxnum;
  191. {
  192.     char **tptr;
  193.     
  194.     if (hdnum >= 0) {
  195.         tptr = entry[hdnum].ob_spec;
  196.     **tptr = '@';
  197.     }
  198.     if (cylnum >= 0) {
  199.         tptr = entry[cylnum].ob_spec;
  200.     **tptr = '@';
  201.     }
  202.     if (btoffst >= 0) {
  203.         tptr = entry[btoffst].ob_spec;
  204.     **tptr = '@';
  205.     }
  206.     objc_draw(entry, boxnum, MAX_DEPTH, 0, 0, wdesk, hdesk);
  207. }
  208.  
  209.     
  210. /*
  211.  *  Check if current entry have valid values and whether
  212.  *  it is a complete entry.
  213.  *    Return OK or the appropiate error defined in deflst.h
  214.  */
  215. chknput(entry, hdnum, cylnum, btoffst)
  216. OBJECT entry[];
  217. int hdnum, cylnum, btoffst;
  218. {
  219.    int numnput=0;    /* number of input found so far */
  220.    char **tptr;
  221.    int num;        /* the inputted number */
  222.  
  223.    /* Check head number */
  224.    tptr = entry[hdnum].ob_spec;
  225.    if (**tptr >= '0' && **tptr <= '9') {
  226.        numnput++;
  227.        if (atoi(*tptr) >= maxpaddr.head)
  228.            return HD2BIG;
  229.    }
  230.    
  231.    /* Check cylinder number */   
  232.    tptr = entry[cylnum].ob_spec;
  233.    if (**tptr >= '0' && **tptr <= '9') {
  234.        numnput++;
  235.        if (!(num = atoi(*tptr)))
  236.            return CYLNUM0;
  237.        if (num >= maxpaddr.cylndr)
  238.            return CYL2BIG;
  239.    }
  240.    
  241.    /* Check byte offset */   
  242.    tptr = entry[btoffst].ob_spec;
  243.    if (**tptr >= '0' && **tptr <= '9') {
  244.        numnput++;
  245.        if (atoi(*tptr) >= maxpaddr.btoffst)
  246.            return BYT2BIG;
  247.    }
  248.    
  249.    if (numnput == 0)
  250.        return EMPTY;
  251.        
  252.    if (numnput < 3)
  253.        return INCMPL;
  254.        
  255.    return OK;
  256. }
  257.  
  258.  
  259.  
  260. /*
  261.  *  Calculate corresponding sector numbers for defects input.
  262.  *    Input:
  263.  *        hinfo - hard disk info. (e.g. #heads, #cylinders, etc..)
  264.  *        pbps - number of bytes per sector physically.
  265.  *            (i.e. including index)
  266.  *    Return:
  267.  *        nbad - number of bad sectors to be added to BSL.
  268.  *        ERROR - if anything is wrong.
  269.  *    Comments:
  270.  *        New calculated sector number is searched for in
  271.  *    badbuf before adding onto it.  This ensures that no duplicates
  272.  *    of a sector would appear in the BSL.
  273.  */
  274. calcsect(hinfo, pbps)
  275. HINFO *hinfo;
  276. int pbps;
  277. {
  278.     int i;        /* index into defect list */
  279.     int ldb;        /* byte number of the last data byte on a track */
  280.     int offset;        /* byte offset from index */
  281.     int rndup;        /* byte offset rndup */
  282.     int spt;        /* sectors per track */
  283.     int spc;        /* sectors per cylinder */
  284.     SECTOR sectnum;    /* sector number on track */
  285.     int j;        /* index into buffer of bad sector numbers */
  286.     int nbad;        /* num bad sectors so far */
  287.     
  288.     spt = hinfo->hi_spt;
  289.     spc = spt * hinfo->hi_dhc;
  290.     ldb = NDXPULS + ((unsigned int)hinfo->hi_spt * pbps) - 1;
  291.     
  292.     nbad = 0;
  293.     for (i = 0; i < npndefs; i++) {
  294.     offset = nppaddr[i].btoffst;
  295.     
  296.         if (fmt != tst) {
  297.             rndup = 0;
  298.             if (offset % 2)
  299.                 rndup = 1;
  300.             if (fmt == RLL && tst == MFM) {
  301.                 offset *= 3;
  302.                 offset >>= 1;
  303.             } else if (fmt == MFM && tst == RLL) {
  304.                 offset <<= 1;
  305.                 offset /= 3;
  306.             }
  307.         offset += rndup;
  308.     }
  309.         
  310.         if (offset < NDXPULS)
  311.             offset = NDXPULS;        /* bump up to 1st data sector */
  312.         else if (offset > ldb)
  313.             offset = ldb;        /* bump back to last data sector */
  314.             
  315.         sectnum = (offset - NDXPULS) / pbps;
  316.         sectnum += (long)(spc * nppaddr[i].cylndr)
  317.                 + (long)(spt * nppaddr[i].head);
  318.         
  319.         for (j = 0; j < nbad; j++)
  320.                if (sectnum == *(badbuf+j))
  321.                 break;
  322.  
  323.         if (j == nbad) {
  324.             *(badbuf+nbad) = sectnum;
  325.             nbad++;
  326.         }
  327.     }
  328.     free(nppaddr);
  329.     return nbad;
  330. }
  331.